from backtesting.test import SMA

/opt/hostedtoolcache/Python/3.11.11/x64/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html
  from .autonotebook import tqdm as notebook_tqdm

from backtesting import Strategy
from backtesting.lib import crossover


class Sma4Cross(Strategy):
    n1 = 50
    n2 = 100
    n_enter = 20
    n_exit = 10
    
    def init(self):
        self.sma1 = self.I(SMA, self.data.Close, self.n1)
        self.sma2 = self.I(SMA, self.data.Close, self.n2)
        self.sma_enter = self.I(SMA, self.data.Close, self.n_enter)
        self.sma_exit = self.I(SMA, self.data.Close, self.n_exit)
        
    def next(self):
        
        if not self.position:
            
            # On upwards trend, if price closes above
            # "entry" MA, go long
            
            # Here, even though the operands are arrays, this
            # works by implicitly comparing the two last values
            if self.sma1 > self.sma2:
                if crossover(self.data.Close, self.sma_enter):
                    self.buy()
                    
            # On downwards trend, if price closes below
            # "entry" MA, go short
            
            else:
                if crossover(self.sma_enter, self.data.Close):
                    self.sell()
        
        # But if we already hold a position and the price
        # closes back below (above) "exit" MA, close the position
        
        else:
            if (self.position.is_long and
                crossover(self.sma_exit, self.data.Close)
                or
                self.position.is_short and
                crossover(self.data.Close, self.sma_exit)):
                
                self.position.close()

%%time 

from backtesting import Backtest
from backtesting.test import GOOG


backtest = Backtest(GOOG, Sma4Cross, commission=.002)

stats, heatmap = backtest.optimize(
    n1=range(10, 110, 10),
    n2=range(20, 210, 20),
    n_enter=range(15, 35, 5),
    n_exit=range(10, 25, 5),
    constraint=lambda p: p.n_exit < p.n_enter < p.n1 < p.n2,
    maximize='Equity Final [$]',
    max_tries=200,
    random_state=0,
    return_heatmap=True)

Backtest.optimize:   0%|          | 0/177 [00:00<?, ?it/s]

Backtest.run:   0%|          | 0/2088 [00:00<?, ?bar/s]

Backtest.run:   0%|          | 0/1968 [00:00<?, ?bar/s]

Backtest.run:   0%|          | 0/2008 [00:00<?, ?bar/s]

Backtest.run:   0%|          | 0/1988 [00:00<?, ?bar/s]

heatmap

n1   n2   n_enter  n_exit
20   60   15       10        8448.64
     80   15       10        8348.38
     100  15       10        9283.02
30   40   20       15       10331.51
          25       15       14441.14
                              ...   
100  200  15       10       10994.65
          20       10        9736.19
                   15       14234.93
          25       10        7732.77
          30       10        8806.70
Name: Equity Final [$], Length: 177, dtype: float64

heatmap.sort_values().iloc[-3:]

n1   n2   n_enter  n_exit
40   60   25       20       15618.15
100  160  20       15       16600.30
50   160  20       15       17149.91
Name: Equity Final [$], dtype: float64

hm = heatmap.groupby(['n1', 'n2']).mean().unstack()
hm = hm[::-1]
hm

%matplotlib inline

import matplotlib.pyplot as plt

fig, ax = plt.subplots()
im = ax.imshow(hm, cmap='viridis')
_ = (
    ax.set_xticks(range(len(hm.columns)), labels=hm.columns),
    ax.set_yticks(range(len(hm)), labels=hm.index),
    ax.set_xlabel('n2'),
    ax.set_ylabel('n1'),
    ax.figure.colorbar(im, ax=ax),
)

from backtesting.lib import plot_heatmaps


plot_heatmaps(heatmap, agg='mean')

%%capture

! pip install sambo  # This is a run-time dependency

#%%time

stats, heatmap, optimize_result = backtest.optimize(
    n1=[10, 100],      # Note: For method="sambo", we
    n2=[20, 200],      # only need interval end-points
    n_enter=[10, 40],
    n_exit=[10, 30],
    constraint=lambda p: p.n_exit < p.n_enter < p.n1 < p.n2,
    maximize='Equity Final [$]',
    method='sambo',
    max_tries=40,
    random_state=0,
    return_heatmap=True,
    return_optimization=True)

Backtest.optimize:   0%|          | 0/40 [00:00<?, ?it/s]

Backtest.run:   0%|          | 0/2048 [00:00<?, ?bar/s]

Backtest.run:   0%|          | 0/2077 [00:00<?, ?bar/s]

heatmap.sort_values().iloc[-3:]

n1  n2  n_enter  n_exit
60  92  40       24       29016.24
67  88  40       30       34017.73
54  84  38       25       37542.84
Name: Equity Final [$], dtype: float64

from sambo.plot import plot_objective

names = ['n1', 'n2', 'n_enter', 'n_exit']
_ = plot_objective(optimize_result, names=names, estimator='et')

from sambo.plot import plot_evaluations

_ = plot_evaluations(optimize_result, names=names)

n2	40	60	80	100	120	140	160	180	200
n1
100	NaN	NaN	NaN	NaN	9694.92	6494.40	10063.31	9010.02	10301.05
90	NaN	NaN	NaN	8275.00	8427.48	8540.80	8771.71	9646.89	7884.19
80	NaN	NaN	NaN	9477.03	6846.68	8042.73	7919.79	9096.51	7900.53
70	NaN	NaN	12498.79	6417.25	9069.63	9034.70	7384.79	8576.84	8286.39
60	NaN	NaN	8027.70	7129.25	9436.62	11145.88	9273.17	8484.34	8491.34
50	NaN	7501.19	8909.36	9270.71	8017.69	12118.29	11939.28	10091.10	8868.40
40	NaN	12103.34	NaN	6930.31	9295.27	11125.64	9847.44	9538.79	9331.12
30	12386.32	10224.44	10360.19	13537.82	11160.57	9967.15	9841.65	9882.30	9331.49
20	NaN	8448.64	8348.38	9283.02	NaN	NaN	NaN	NaN	NaN

Parameter Heatmap¶

Model-based optimization¶